package affichage;


import java.awt.Color;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.text.NumberFormat;

import javax.swing.BorderFactory;
import javax.swing.ButtonGroup;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JFormattedTextField;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JRadioButton;

import deroulementjeu.Partie;

import terrain.TypeTerrain;
import unite.TypeUnite;


/**
 * Panel qui sera affiché sur la droite de la fenêtre de l'éditeur de cartes.
 * @author Alexis BRASY, Geoffrey LEQUESNE, Sandrine PIRIOU, Michel POPOV
 */
public class EditeurMenuDroit extends JPanel implements MouseListener {
	
	/** Entier nécssaire à la sérialisation */
    private static final long serialVersionUID = 1L;
    
    /** Les boutons radio qui servent à savoir si l'utilisateur veut ajouter
     * une unité ou un type de terrain sur le terrain */
    private JRadioButton ajoutUnite, ajoutTerrain;
    /** Le panel principal */
    private JPanel panOption;
    /** La fenêtre JFrame qui contient notre objet EditeurMenuDroit */
    private EditeurView fenetre;
    /** La partie que l'on est en train de créer */
    private Partie partie;
    /** Les deux box pour la taille du terrain */
    private JFormattedTextField tailleX = new JFormattedTextField(
            NumberFormat.getIntegerInstance());
    private JFormattedTextField tailleY = new JFormattedTextField(
            NumberFormat.getIntegerInstance());
    /** La vue du terrain */
    private TerrainView terV;
    /** La fenêtre du menu principal */
    private Fenetre menuPrincip;
	
    // Dans le cas d'un ajout d'unité ----------------------------------

    /** Les boutons radio qui servent à savoir à quelle équipe appartient l'unité
     * que l'utilisateur va ajouter */
    private JRadioButton equ1, equ2, equ3;
    /** Le label de la combo box typeUnite */
    private JLabel typeUniteLabel;
    /** La combobox qui sert à determiner le type d'unité que l'utilisateur veut ajouter */
    private JComboBox typeUnite;
    /** Le panel contenant toutes les infos pour ajouter une unité */
    private JPanel panAjoutUnite;
    /** Le type d'unité à ajouter choisi par l'utilisateur (en fonction de la
     * combo box typeUnite) */
    private TypeUnite typeU;
	
    // Dans le cas d'un ajout de terrain ----------------------------------
	
    /** Les boutons radio qui servent à savoir quelle est la taille du pinceau
     * pour ajouter un type de terrain sur le terrain */
    private JRadioButton case1x1, case2x2, case4x4;
    /** La combobox qui sert à determiner le type de terrain que l'utilisateur veut ajouter */
    private JComboBox typeTerrain;
    /** Le panel contenant toutes les infos pour ajouter un terrain */
    private JPanel panAjoutTerrain;
    /** Le type de terrain à ajouter choisi par l'utilisateur (en fonction de la
     * combo box typeTerrain) */
    private TypeTerrain typeT;
	
    
	
    /**
     * Constructeur d'un EditeurMenuDroit
     * @param fenetre la fenêtre (EditeurView) qui contient l'objet
     * @param p la partie
     * @param ter le TerrainView
     * @param menu la fenêtre (Fenetre) qui contient le menu principal
     */
    public EditeurMenuDroit(EditeurView fenetre, Partie p, TerrainView ter, Fenetre menu) {
        this.menuPrincip = menu;
        this.terV = ter;
        this.partie = p;
        this.fenetre = fenetre;
        // Le menu aura la taille 300*la taille de la fenêtre
        this.setPreferredSize(new Dimension(300, this.fenetre.getHeight()));
		
        // Par défaut, on met le type d'unité à EAU et le type de terrain à
        // PLAINE
        typeU = TypeUnite.EAU;
        typeT = TypeTerrain.PLAINE;
		
        // JPanel qui affiche la taille du terrain et "actualiser" pour la modifier
        JPanel tailleTer = new JPanel();

        tailleTer.setBackground(Color.white);
        tailleTer.setBorder(
                BorderFactory.createTitledBorder("La taille du Terrain"));
        tailleTer.setPreferredSize(new Dimension(300, 70));
        tailleX = new JFormattedTextField(NumberFormat.getIntegerInstance());
        tailleX.setValue(partie.getTerrain().getNbLignes());
        tailleX.setPreferredSize(new Dimension(30, 25));
        JLabel labelTailleX = new JLabel("x");

        tailleY = new JFormattedTextField(NumberFormat.getIntegerInstance());
        tailleY.setValue(partie.getTerrain().getNbColonnes());
        tailleY.setPreferredSize(new Dimension(30, 25));
        tailleTer.add(tailleX);
        tailleTer.add(labelTailleX);
        tailleTer.add(tailleY);
        // Le bouton pour actualiser la taille
        JButton actuTaille = new JButton("Actualiser");

        actuTaille.addActionListener(new ActualiserListener());
        tailleTer.add(actuTaille);
        this.add(tailleTer);
		
        // JPanel qui affichera le choix entre l'ajout d'une unité ou d'un terrain
        JPanel choix = new JPanel();
		
        choix.setBackground(Color.white);
        // Le cadre avec le titre
        choix.setBorder(
                BorderFactory.createTitledBorder("Que voulez-vous ajouter ?"));
        // La taille du JPanel
        choix.setPreferredSize(new Dimension(300, 70));
        // Les deux JRadioButton (une unité - un terrain)
        ajoutUnite = new JRadioButton("une unité");
        ajoutUnite.setSelected(true);
        ajoutTerrain = new JRadioButton("un terrain");
        // On ajoute les deux JRadioButton au même groupe
        ButtonGroup bg2 = new ButtonGroup();

        bg2.add(ajoutUnite);
        bg2.add(ajoutTerrain);
        // On ajoute les deux boutons dans le JPanel Choix
        choix.add(ajoutUnite);
        choix.add(ajoutTerrain);
        // On écoute les deux boutons
        ajoutUnite.addActionListener(new ChoixListener(this));
        ajoutTerrain.addActionListener(new ChoixListener(this));
        // On ajoute le JPanel Choix au panel EditeurMenuDroit
        this.add(choix);
		
        // Le Panel AJOUT UNITE
		
        panAjoutUnite = new JPanel();
        panAjoutUnite.setBackground(Color.white);
        panAjoutUnite.setBorder(
                BorderFactory.createTitledBorder("Ajout d'une unité"));
        panAjoutUnite.setPreferredSize(new Dimension(300, 180));
		
        JPanel equipe = new JPanel();

        equipe.setBackground(Color.white);
        equipe.setBorder(BorderFactory.createTitledBorder("Équipe de l'unité"));
        equipe.setPreferredSize(new Dimension(250, 60));
        equ1 = new JRadioButton("Équipe A");
        equ1.setSelected(true);
        equ2 = new JRadioButton("Équipe B");
        equ3 = new JRadioButton("Autre");
        ButtonGroup bg = new ButtonGroup();

        bg.add(equ1);
        bg.add(equ2);
        bg.add(equ3);
        equipe.add(equ1);
        equipe.add(equ2);
        equipe.add(equ3);
        equ1.addActionListener(new StateListener());
        equ2.addActionListener(new StateListener());
        equ3.addActionListener(new StateListener());
		
        JPanel pantypeUnite = new JPanel();

        pantypeUnite.setBackground(Color.white);
        pantypeUnite.setPreferredSize(new Dimension(250, 60));
        pantypeUnite.setBorder(BorderFactory.createTitledBorder("Type d'unité"));
        typeUnite = new JComboBox();
        if (equ1.isSelected() || equ2.isSelected()) {
            typeUnite.addItem("Eau");
            typeUnite.addItem("Plante");
            typeUnite.addItem("Feu");
            typeUnite.addItem("Vol");
            typeUnite.addItem("Électrique");
            typeUnite.addItem("Dresseur");
        } else if (equ3.isSelected()) {
            typeUnite.addItem("Potion");
            typeUnite.addItem("Obstacle");
            typeUnite.addItem("Téléporteur");
        }
        typeUnite.addItemListener(new ItemState());
        typeUniteLabel = new JLabel("Type : ");
        pantypeUnite.add(typeUniteLabel);
        pantypeUnite.add(typeUnite);
		
        panOption = new JPanel();
        
        panAjoutUnite.add(equipe);
        panAjoutUnite.add(pantypeUnite);
        panOption.add(panAjoutUnite);
        this.add(panOption);
        
        // Le Panel AJOUT TERRAIN
        panAjoutTerrain = new JPanel();
        panAjoutTerrain.setBackground(Color.white);
        panAjoutTerrain.setBorder(
                BorderFactory.createTitledBorder("Ajout d'un terrain"));
        panAjoutTerrain.setPreferredSize(new Dimension(300, 180));
		
        JPanel pantypeTerrain = new JPanel();

        pantypeTerrain.setBackground(Color.white);
        pantypeTerrain.setPreferredSize(new Dimension(250, 60));
        pantypeTerrain.setBorder(
                BorderFactory.createTitledBorder("Type de terrain"));
        typeTerrain = new JComboBox();
        typeTerrain.addItem("Plaine");
        typeTerrain.addItem("Sable");
        typeTerrain.addItem("Montagne");
        typeTerrain.addItem("Mer");
        typeTerrain.addItem("Forêt");
        typeTerrain.addItem("Glace");
        typeTerrain.addItem("Vide");
        typeTerrain.addItemListener(new ItemState2());
        panAjoutTerrain.add(typeTerrain);
		
        JPanel nombreCase = new JPanel();

        nombreCase.setBackground(Color.white);
        nombreCase.setPreferredSize(new Dimension(250, 100));
        nombreCase.setBorder(
                BorderFactory.createTitledBorder("Taille du pinceau"));
        Icon iconPetit = new ImageIcon("img/petitpinceau.gif");
        Icon iconMoyen = new ImageIcon("img/moyenpinceau.gif");
        Icon iconGrand = new ImageIcon("img/grandpinceau.gif");

        case1x1 = new JRadioButton(iconPetit);
        case1x1.setSelected(true);
        case2x2 = new JRadioButton(iconMoyen);
        case4x4 = new JRadioButton(iconGrand);
        ButtonGroup bg3 = new ButtonGroup();

        bg3.add(case1x1);
        bg3.add(case2x2);
        bg3.add(case4x4);
        nombreCase.add(case1x1);
        nombreCase.add(case2x2);
        nombreCase.add(case4x4);
        case1x1.addActionListener(new StateListener2());
        case2x2.addActionListener(new StateListener2());
        case4x4.addActionListener(new StateListener2());
        panAjoutTerrain.add(nombreCase);
		
        // LE PANEL SAUVEGARDER/CHARGER
        JPanel save = new JPanel();

        save.setBackground(Color.white);
        save.setBorder(BorderFactory.createTitledBorder("Sauvegarder/Charger"));
        save.setPreferredSize(new Dimension(250, 80));
        Bouton butSave = new Bouton("Sauvegarder", partie, ter, this);

        save.add(butSave);
        Bouton butCharg = new Bouton("Charger", partie, ter, this);

        save.add(butCharg);
        this.add(save);
		
        // LE PANEL QUITTER L'EDITEUR
        JPanel back = new JPanel();

        back.setBackground(Color.white);
        back.setBorder(
                BorderFactory.createTitledBorder("Revenir au menu principal"));
        back.setPreferredSize(new Dimension(250, 80));
        Bouton butBack = new Bouton("Menu Principal", partie, ter, this);

        back.add(butBack);
        butBack.addActionListener(new BackListener());
        this.add(back);
		
    }
	
    /**
     * Setter du nombre de lignes de la carte dans le cadre "Taille du terrain"
     */
    public void setTailleX() {
        tailleX.setValue(partie.getTerrain().getNbLignes());
    }
	
    /**
     * Setter du nombre de colonnes de la carte dans le cadre "Taille du terrain"
     */
    public void setTailleY() {
        tailleY.setValue(partie.getTerrain().getNbLignes());
    }
	
    /**
     * Getter du bouton ajoutUnite (utilisé dans TerrainView pour savoir
     * s'il est sélectionné ou non)
     * @return le JRadioButton
     */
    public JRadioButton getAjoutUnite() {
        return ajoutUnite;
    }

    /**
     * Getter du bouton ajoutTerrain (utilisé dans TerrainView pour savoir
     * s'il est sélectionné ou non)
     * @return le JRadioButton
     */
    public JRadioButton getAjoutTerrain() {
        return ajoutTerrain;
    }

    /**
     * Getter du bouton equ1 (utilisé dans TerrainView pour savoir
     * à quelle équipe appartient l'unité à ajouter)
     * @return le JRadioButton
     */
    public JRadioButton getEqu1() {
        return equ1;
    }

    /**
     * Getter du bouton equ2 (utilisé dans TerrainView pour savoir
     * à quelle équipe appartient l'unité à ajouter)
     * @return le JRadioButton
     */
    public JRadioButton getEqu2() {
        return equ2;
    }

    /**
     * Getter du bouton equ3 (utilisé dans TerrainView pour savoir
     * à quelle équipe appartient l'unité à ajouter)
     * @return le JRadioButton
     */
    public JRadioButton getEqu3() {
        return equ3;
    }

    /**
     * Getter du bouton case1x1 (utilisé dans TerrainView pour savoir
     * quelle taille du pinceau est sélectionnée)
     * @return le JRadioButton
     */
    public JRadioButton getCase1x1() {
        return case1x1;
    }

    /**
     * Getter du bouton case2x2 (utilisé dans TerrainView pour savoir
     * quelle taille du pinceau est sélectionnée)
     * @return le JRadioButton
     */
    public JRadioButton getCase2x2() {
        return case2x2;
    }

    /**
     * Getter du bouton case4x4 (utilisé dans TerrainView pour savoir
     * quelle taille du pinceau est sélectionnée)
     * @return le JRadioButton
     */
    public JRadioButton getCase4x4() {
        return case4x4;
    }

    /**
     * Getter du type d'unité à ajouter
     * @return le type d'unité
     */
    public TypeUnite getTypeUnite() {
        return typeU;
    }

    /**
     * Setter du type d'unité à ajouter
     * @param type le type d'unité
     */
    public void setTypeUnite(TypeUnite type) {
        this.typeU = type;
    }
	
    /**
     * Getter du type de terrain à ajouter
     * @return le type de terrain
     */
    public TypeTerrain getTypeTerrain() {
        return typeT;
    }

    /**
     * Setter du type de terrain à ajouter
     * @param type le type de terrain
     */
    public void setTypeTerrain(TypeTerrain type) {
        this.typeT = type;
    }

    /**
     * Setter de la partie
     * @param p la partie
     */
    public void setPartie(Partie p) {
        this.partie = p;
    }
	
    @Override
    public void mouseClicked(MouseEvent e) {}

    @Override
    public void mouseEntered(MouseEvent e) {}

    @Override
    public void mouseExited(MouseEvent e) {}

    @Override
    public void mousePressed(MouseEvent e) {}

    @Override
    public void mouseReleased(MouseEvent e) {}
    
    /**
     * Classe qui écoute les boutons radio d'ajout du terrain ou d'une unité
     * @author Alexis BRASY, Geoffrey LEQUESNE, Sandrine PIRIOU, Michel POPOV
     *
     */
    class ChoixListener implements ActionListener {
        EditeurMenuDroit edit;
        boolean premiereFois = true;
		
        /**
         * Constructeur d'un ChoixListener
         * @param e l'éditeur menu droit sur lequel les boutons sont placés
         */
        public ChoixListener(EditeurMenuDroit e) {
            edit = e;
        }
		
        /**
         * Redéfinition de la méthode actionPerformed
         */
        @Override
        public void actionPerformed(ActionEvent e) {
        	// Si ajouter unité est séléctionné, on enlève le panel ajout terrain
        	// et on ajoute le panel ajout unité
            if (ajoutUnite.isSelected()) {
                panOption.remove(panAjoutTerrain);
                panOption.add(panAjoutUnite);
                edit.repaint();
                panOption.repaint();
            }
            // Si ajouter terrain est séléctionné, on enlève le panel ajout unité
        	// et on ajoute le panel ajout terrain
            else if (ajoutTerrain.isSelected()) {
                panOption.remove(panAjoutUnite);
                panOption.add(panAjoutTerrain);
                panAjoutTerrain.repaint();
                edit.repaint();
                panOption.repaint();
				
                // Si c'est la première fois, on redimensionne la fenêtre pour l'afficher
                // sinon il ne s'affichera pas
                if (premiereFois) {
                    premiereFois = false;
                    fenetre.setSize(fenetre.getWidth() + 1, fenetre.getHeight());
                    fenetre.setSize(fenetre.getWidth() - 1, fenetre.getHeight());
                }
            }
        }
    }
	
	/**
	 * Classe qui écoute les boutons radios de l'équipe
	 * @author Alexis BRASY, Geoffrey LEQUESNE, Sandrine PIRIOU, Michel POPOV
	 *
	 */
    class StateListener implements ActionListener {
		 
    	/** 
    	 * Redéfinition de la méthode actionPerformed
    	 */
        @Override
        public void actionPerformed(ActionEvent e) {
        	// Si on a sélectionné une équipe jouable
            if (equ1.isSelected() || equ2.isSelected()) {
                typeUnite.removeAllItems();
                typeUnite.addItem("Eau");
                typeUnite.addItem("Plante");
                typeUnite.addItem("Feu");
                typeUnite.addItem("Vol");
                typeUnite.addItem("Électrique");
                typeUnite.addItem("Dresseur");
            }
            // Sinon si c'est l'équipe des objets
            else if (equ3.isSelected()) {
                typeUnite.removeAllItems();
                typeUnite.addItem("Potion");
                typeUnite.addItem("Obstacle");
                // typeUnite.addItem("Téléporteur");
            }
        }
    }
	

    /**
	 * Classe qui écoute les boutons de la taille du pinceau pour ajouter du terrain
	 * @author Alexis BRASY, Geoffrey LEQUESNE, Sandrine PIRIOU, Michel POPOV
	 *
	 */
    class StateListener2 implements ActionListener {
		 
    	/**
    	 * Redéfinition de la méthode actionPerformed
    	 */
        @Override
        public void actionPerformed(ActionEvent e) {
            if (case1x1.isSelected()) {// 
            } else if (case2x2.isSelected()) {// 
            } else if (case4x4.isSelected()) {// 
            }
        }
    }
	

    /**
     * Classe qui écoute les JComboBox de type d'unité et type de terrain
     * @author Alexis BRASY, Geoffrey LEQUESNE, Sandrine PIRIOU, Michel POPOV
     *
     */
    class ItemState implements ItemListener {
		 
        public void itemStateChanged(ItemEvent e) {
            if (e.getItem().equals("Eau")) {
                typeU = TypeUnite.EAU;
            } else if (e.getItem().equals("Feu")) {
                typeU = TypeUnite.FEU;
            } else if (e.getItem().equals("Électrique")) {
                typeU = TypeUnite.ELECTRIQUE;
            } else if (e.getItem().equals("Plante")) {
                typeU = TypeUnite.PLANTE;
            } else if (e.getItem().equals("Vol")) {
                typeU = TypeUnite.VOL;
            } else if (e.getItem().equals("Dresseur")) {
                typeU = TypeUnite.DRESSEUR;
            } else if (e.getItem().equals("Potion")) {
                typeU = TypeUnite.POTION;
            } /*
             else if(e.getItem().equals("Teleporteur")) {
             typeU=TypeUnite.TELEPORTEUR;
             }
             */ else if (e.getItem().equals("Obstacle")) {
                typeU = TypeUnite.OBSTACLE;
            }
        }
    }
        

    /**
     * Classe qui écoute les JComboBox de type d'unité et type de terrain
     * @author Alexis BRASY, Geoffrey LEQUESNE, Sandrine PIRIOU, Michel POPOV
     *
     */
    class ItemState2 implements ItemListener {
   		 
        public void itemStateChanged(ItemEvent e) {
            if (e.getItem().equals("Plaine")) {
                typeT = TypeTerrain.PLAINE;
            } else if (e.getItem().equals("Sable")) {
                typeT = TypeTerrain.SABLE;
            } else if (e.getItem().equals("Montagne")) {
                typeT = TypeTerrain.MONTAGNE;
            } else if (e.getItem().equals("Mer")) {
                typeT = TypeTerrain.MER;
            } else if (e.getItem().equals("Vide")) {
                typeT = TypeTerrain.VIDE;
            } else if (e.getItem().equals("Glace")) {
                typeT = TypeTerrain.GLACE;
            } else if (e.getItem().equals("Forêt")) {
                typeT = TypeTerrain.FORET;
            }
        }
    }
        
    /**
     * Classe qui écoute le bouton "Actualiser" de la taille du terrain
     * et le redimensionne en fonction des cases remplies par l'utilisateur
     * @author Alexis BRASY, Geoffrey LEQUESNE, Sandrine PIRIOU, Michel POPOV
     *
     */
    class ActualiserListener implements ActionListener {

    	/**
    	 * Redéfinition de la méthode actionPerformed
    	 */
        @Override
        public void actionPerformed(ActionEvent e) {
            int entierTailleX = Integer.parseInt(tailleX.getText());
            int entierTailleY = Integer.parseInt(tailleY.getText());

            if (entierTailleX > 0 && entierTailleY > 0) {
                partie.getTerrain().redimTerrain(entierTailleX, entierTailleY);
					
                terV.setTerrain(partie.getTerrain());
                terV.redimTerrainView(terV.getTerrain());
				terV.setPreferredSize(new Dimension(terV.getTerrain().getNbColonnes()*terV.getCaseTerrainView().get(0).get(0).getHexaWidth()+terV.getCaseTerrainView().get(0).get(0).getHexaWidth()/2,terV.getTerrain().getNbLignes()*terV.getCaseTerrainView().get(0).get(0).getHexaSide()+terV.getCaseTerrainView().get(0).get(0).getHexaHeight()-terV.getCaseTerrainView().get(0).get(0).getHexaSide()));
					
                fenetre.setSize(fenetre.getWidth() + 1, fenetre.getHeight());
                fenetre.setSize(fenetre.getWidth() - 1, fenetre.getHeight());
                paintImmediately(0, 0, fenetre.getWidth(), fenetre.getHeight());
            }
        }
    }
        
    /**
     * Classe qui écoute le bouton "Menu principal"
     * @author Alexis BRASY, Geoffrey LEQUESNE, Sandrine PIRIOU, Michel POPOV
     *
     */
    class BackListener implements ActionListener {

    	/**
    	 * Redéfinition de la méthode actionPerformed
    	 */
        @Override
        public void actionPerformed(ActionEvent e) {
        	// On efface et cache toute cette fenêtre, on réaffiche la fenêtre du menu
            fenetre.removeAll();
            fenetre.setVisible(false);
            menuPrincip.setVisible(true);
            menuPrincip.lancerMusiqueMenu();
        }
        	
    }
    
    

}
